JavaScript Asinxron Generatorlarida Teskari Bosim: Oqimni Boshqarish Bo'yicha To'liq Qo'llanma

Ko'p ma'lumot talab qiladigan ilovalar dunyosida biz tez-tez klassik muammoga duch kelamiz: tezkor ma'lumot manbasi ma'lumotni iste'molchi qayta ishlay oladiganidan ancha tezroq ishlab chiqaradi. Tasavvur qiling, bog' purkagichiga yong'in shlangi ulangan. Oqimni nazorat qiladigan klapansiz sizda hamma yoqni suv bosadi. Dasturiy ta'minotda esa bu "suv toshqini" xotiraning to'lib ketishiga, ilovalarning javob bermay qolishiga va oxir-oqibat ishdan chiqishiga olib keladi. Bu fundamental muammo teskari bosim deb ataladigan tushuncha bilan boshqariladi va zamonaviy JavaScript buning uchun o'ziga xos nafis yechimni taklif etadi: Asinxron Generatorlar.

Ushbu keng qamrovli qo'llanma sizni JavaScript'dagi oqimlarni qayta ishlash va oqimni boshqarish dunyosiga chuqur olib kiradi. Biz teskari bosim nima ekanligini, nima uchun u mustahkam tizimlarni yaratish uchun juda muhimligini va asinxron generatorlar uni boshqarish uchun qanday qilib intuitiv, o'rnatilgan mexanizmni taqdim etishini o'rganamiz. Katta hajmdagi fayllarni qayta ishlayapsizmi, real vaqtdagi API'lardan foydalanayapsizmi yoki murakkab ma'lumotlar konveyerlarini quryapsizmi, bu andozani tushunish sizning asinxron kod yozish uslubingizni tubdan o'zgartiradi.

1. Asosiy Tushunchalarni Tahlil Qilish

Yechimni yaratishdan oldin, avvalo jumboqning asosiy qismlarini tushunib olishimiz kerak. Keling, asosiy atamalarga aniqlik kiritaylik: oqimlar, teskari bosim va asinxron generatorlarning sehri.

Oqim (Stream) nima?

Oqim - bu bir bo'lak ma'lumot emas; bu vaqt o'tishi bilan mavjud bo'ladigan ma'lumotlar ketma-ketligi. Butun 10 gigabaytli faylni bir vaqtning o'zida xotiraga o'qish o'rniga (bu, ehtimol, ilovangizni ishdan chiqaradi), siz uni oqim sifatida, qismlarga bo'lib o'qishingiz mumkin. Bu tushuncha hisoblash sohasida universaldir:

• Fayllar bilan ishlash (I/O): Katta log faylini o'qish yoki video ma'lumotlarini yozish.
• Tarmoq: Faylni yuklab olish, WebSocket'dan ma'lumotlarni qabul qilish yoki video kontentni oqimlash.
• Protsesslararo aloqa: Bir dasturning chiqishini boshqasining kirishiga yo'naltirish.

Oqimlar samaradorlik uchun zarur bo'lib, ular bizga minimal xotira sarflagan holda katta hajmdagi ma'lumotlarni qayta ishlash imkonini beradi.

Teskari Bosim (Backpressure) nima?

Teskari bosim - bu ma'lumotlarning kerakli oqimiga qarshi turadigan qarshilik yoki kuch. Bu sekin ishlaydigan iste'molchiga tez ishlaydigan ishlab chiqaruvchiga "Hey, sekinroq ishla! Men ulgura olmayapman." deb signal berish imkonini beruvchi qayta aloqa mexanizmi.

Keling, klassik o'xshatishdan foydalanamiz: zavod yig'ish liniyasi.

• Ishlab chiqaruvchi - bu birinchi stansiya bo'lib, konveyer lentasiga qismlarni yuqori tezlikda qo'yadi.
• Iste'molchi - bu oxirgi stansiya bo'lib, har bir qism ustida sekin va batafsil yig'ish ishlarini bajarishi kerak.

Agar ishlab chiqaruvchi juda tez ishlasa, qismlar to'planib qoladi va oxir-oqibat iste'molchiga yetib bormasdan lentadan tushib ketadi. Bu ma'lumotlar yo'qolishi va tizimning ishdan chiqishidir. Teskari bosim - bu iste'molchining liniya bo'ylab orqaga yuboradigan signali bo'lib, ishlab chiqaruvchiga yetib olgunicha to'xtab turishini aytadi. Bu butun tizimning eng sekin komponenti tezligida ishlashini ta'minlaydi va ortiqcha yuklanishni oldini oladi.

Teskari bosimsiz siz quyidagi xavflarga duch kelasiz:

• Cheksiz Buferlash: Ma'lumotlar xotirada to'planib, RAMning ko'p ishlatilishiga va potensial ishdan chiqishlarga olib keladi.
• Ma'lumotlar Yo'qolishi: Agar buferlar to'lib ketsa, ma'lumotlar tashlab yuborilishi mumkin.
• Voqealar Halqasining Bloklanishi: Node.js'da haddan tashqari yuklangan tizim voqealar halqasini (event loop) bloklashi mumkin, bu esa ilovani javob bermaydigan holga keltiradi.

Tez Eslatma: Generatorlar va Asinxron Iteratorlar

Zamonaviy JavaScript'da teskari bosim muammosining yechimi bajarilishni to'xtatib turish va qayta davom ettirish imkonini beruvchi xususiyatlarda yotadi. Keling, ularni tezda ko'rib chiqaylik.

Generatorlar (`function*`): Bular chiqib ketish va keyinroq qayta kirish mumkin bo'lgan maxsus funksiyalardir. Ular `yield` kalit so'zidan foydalanib, "to'xtab turadi" va qiymat qaytaradi. Keyin chaqiruvchi funksiyaning bajarilishini keyingi qiymatni olish uchun qachon davom ettirishni hal qilishi mumkin. Bu sinxron ma'lumotlar uchun talabga asoslangan tortish tizimini yaratadi.

Asinxron Iteratorlar (`Symbol.asyncIterator`): Bu asinxron ma'lumot manbalari ustida qanday iteratsiya qilishni belgilaydigan protokoldir. Agar ob'ektda `Symbol.asyncIterator` kaliti bilan metod mavjud bo'lsa va u `next()` metodiga ega ob'ektni qaytarsa, u asinxron takrorlanuvchi (iterable) hisoblanadi. Bu `next()` metodi `{ value, done }` ga aylantiriladigan Promise qaytaradi.

Asinxron Generatorlar (`async function*`): Bu yerda hamma narsa birlashadi. Asinxron generatorlar generatorlarning to'xtab turish xususiyatini Promise'larning asinxron tabiati bilan birlashtiradi. Ular vaqt o'tishi bilan keladigan ma'lumotlar oqimini ifodalash uchun mukammal vositadir.

Siz asinxron generatorni kuchli `for await...of` sikli yordamida iste'mol qilasiz, bu esa `.next()` ni chaqirish va promise'larning hal bo'lishini kutish murakkabligini yashiradi.

            
async function* countToThree() {
  yield 1; // To'xtatish va 1 ni qaytarish
  await new Promise(resolve => setTimeout(resolve, 1000)); // Asinxron kutish
  yield 2; // To'xtatish va 2 ni qaytarish
  await new Promise(resolve => setTimeout(resolve, 1000));
  yield 3; // To'xtatish va 3 ni qaytarish
}

async function main() {
  console.log("Iste'molni boshlash...");
  for await (const number of countToThree()) {
    console.log(number); // Bu 1 ni, keyin 1 soniyadan so'ng 2 ni, yana 1 soniyadan so'ng 3 ni chiqaradi
  }
  console.log("Iste'mol tugadi.");
}

main();

            

              
                Copy
              
            
          

`for await...of` sikli generatordan qiymatlarni *tortib olishi* eng muhim tushunchadir. U sikl ichidagi kod joriy qiymat uchun bajarilishini tugatmaguncha keyingi qiymatni so'ramaydi. Bu o'ziga xos tortishga asoslangan tabiat avtomatik teskari bosimning siridir.

2. Muammoning Ko'rinishi: Teskari Bosimsiz Oqim

Yechimni chinakam qadrlash uchun keng tarqalgan, ammo noto'g'ri andozani ko'rib chiqaylik. Tasavvur qiling, bizda juda tez ma'lumot manbasi (ishlab chiqaruvchi) va sekin ma'lumotlarni qayta ishlovchi (iste'molchi) bor, ehtimol u sekin ma'lumotlar bazasiga yozadi yoki tezligi cheklangan API'ni chaqiradi.

Bu yerda an'anaviy voqea-emitter (event-emitter) yoki qayta chaqiruv (callback) uslubidan foydalangan holda simulyatsiya qilingan, bu itarishga asoslangan (push-based) tizimdir.

            
// Juda tez ma'lumot manbasini ifodalaydi
class FastProducer {
  constructor() {
    this.listeners = [];
  }

  onData(listener) {
    this.listeners.push(listener);
  }

  start() {
    let id = 0;
    // Har 10 millisekundda ma'lumot ishlab chiqarish
    this.interval = setInterval(() => {
      const data = { id: id++, timestamp: Date.now() };
      console.log(`ISH. CHIQARUVCHI: ${data.id}-elementni uzatmoqda`);
      this.listeners.forEach(listener => listener(data));
    }, 10);
  }

  stop() {
    clearInterval(this.interval);
  }
}

// Sekin iste'molchini ifodalaydi (masalan, sekin tarmoq xizmatiga yozish)
async function slowConsumer(data) {
  console.log(`  ISTE'MOLCHI: ${data.id}-elementni qayta ishlashni boshlamoqda...`);
  // 500 millisekund davom etadigan sekin I/O operatsiyasini simulyatsiya qilish
  await new Promise(resolve => setTimeout(resolve, 500));
  console.log(`  ISTE'MOLCHI: ...${data.id}-elementni qayta ishlashni tugatdi`);
}

// --- Keling, simulyatsiyani ishga tushiramiz ---
const producer = new FastProducer();
const dataBuffer = [];

producer.onData(data => {
  console.log(`${data.id}-element qabul qilindi, buferga qo'shilmoqda.`);
  dataBuffer.push(data);
  // Qayta ishlashga sodda urinish
  // slowConsumer(data); // Agar buni kutganimizda, u yangi voqealarni bloklar edi
});

producer.start();

// Qisqa vaqtdan so'ng buferni tekshiramiz
setTimeout(() => {
  producer.stop();
  console.log(`\n--- 2 soniyadan so'ng ---`);
  console.log(`Bufer hajmi: ${dataBuffer.length}`);
  console.log(`Ishlab chiqaruvchi taxminan 200 ta element yaratdi, ammo iste'molchi faqat 4 tasini qayta ishlagan bo'lardi.`);
  console.log(`Qolgan 196 ta element xotirada kutib turibdi.`);
}, 2000);


            

              
                Copy
              
            
          

Bu Yerda Nima Bo'lyapti?

Ishlab chiqaruvchi har 10ms da ma'lumot uzatmoqda. Iste'molchiga bitta elementni qayta ishlash uchun 500ms kerak bo'ladi. Ishlab chiqaruvchi iste'molchidan 50 baravar tezroq!

Ushbu itarishga asoslangan modelda ishlab chiqaruvchi iste'molchining holatidan mutlaqo bexabar. U shunchaki ma'lumotlarni itarishda davom etadi. Bizning kodimiz kiruvchi ma'lumotlarni shunchaki `dataBuffer` massiviga qo'shadi. Atigi 2 soniya ichida bu bufer deyarli 200 ta elementni o'z ichiga oladi. Soatlab ishlaydigan haqiqiy ilovada bu bufer cheksiz o'sib, barcha mavjud xotirani egallab oladi va jarayonni ishdan chiqaradi. Bu teskari bosim muammosining eng xavfli shaklidir.

3. Yechim: Asinxron Generatorlar Bilan Ichki Teskari Bosim

Endi, xuddi shu stsenariyni asinxron generator yordamida qayta tuzaylik. Biz ishlab chiqaruvchini "itaruvchi" dan "tortib olinadigan" narsaga aylantiramiz.

Asosiy g'oya ma'lumot manbasini `async function*` ichiga o'rashdir. Iste'molchi esa `for await...of` siklidan foydalanib, faqat ko'proq ma'lumotga tayyor bo'lganda ma'lumotlarni tortib oladi.

            
// ISH. CHIQARUVCHI: Asinxron generatorga o'ralgan ma'lumot manbasi
async function* createFastProducer() {
  let id = 0;
  while (true) {
    // Tez ma'lumot manbasi element yaratishini simulyatsiya qilish
    await new Promise(resolve => setTimeout(resolve, 10));
    const data = { id: id++, timestamp: Date.now() };
    console.log(`ISH. CHIQARUVCHI: ${data.id}-elementni yield qilmoqda`);
    yield data; // Iste'molchi keyingi elementni so'ramaguncha to'xtab turish
  }
}

// ISTE'MOLCHI: Oldingidek sekin jarayon
async function slowConsumer(data) {
  console.log(`  ISTE'MOLCHI: ${data.id}-elementni qayta ishlashni boshlamoqda...`);
  // 500 millisekund davom etadigan sekin I/O operatsiyasini simulyatsiya qilish
  await new Promise(resolve => setTimeout(resolve, 500));
  console.log(`  ISTE'MOLCHI: ...${data.id}-elementni qayta ishlashni tugatdi`);
}

// --- Asosiy bajarilish mantig'i ---
async function main() {
  const producer = createFastProducer();

  // `for await...of` sehri
  for await (const data of producer) {
    await slowConsumer(data);
  }
}

main();

            

              
                Copy
              
            
          

Bajarilish Oqimini Tahlil Qilaylik

Agar siz bu kodni ishga tushirsangiz, keskin farqli natijani ko'rasiz. U quyidagicha ko'rinishga ega bo'ladi:

ISH. CHIQARUVCHI: 0-elementni yield qilmoqda
  ISTE'MOLCHI: 0-elementni qayta ishlashni boshlamoqda...
  ISTE'MOLCHI: ...0-elementni qayta ishlashni tugatdi
ISH. CHIQARUVCHI: 1-elementni yield qilmoqda
  ISTE'MOLCHI: 1-elementni qayta ishlashni boshlamoqda...
  ISTE'MOLCHI: ...1-elementni qayta ishlashni tugatdi
ISH. CHIQARUVCHI: 2-elementni yield qilmoqda
  ISTE'MOLCHI: 2-elementni qayta ishlashni boshlamoqda...
  ...

Mukammal sinxronizatsiyaga e'tibor bering. Ishlab chiqaruvchi yangi elementni faqatgina iste'molchi avvalgisini to'liq qayta ishlab bo'lgandan *so'ng* yield qiladi. O'sib boruvchi bufer yo'q va xotira sizib chiqishi yo'q. Teskari bosim avtomatik ravishda ta'minlanadi.

Bu nima uchun ishlashining bosqichma-bosqich tahlili:

1. `for await...of` sikli boshlanadi va birinchi elementni so'rash uchun parda ortida `producer.next()` ni chaqiradi.
2. `createFastProducer` funksiyasi bajarilishni boshlaydi. U 10ms kutadi, 0-element uchun `data` ni yaratadi va keyin `yield data` ga uriladi.
3. Generator o'z ijrosini to'xtatadi va yield qilingan qiymat bilan hal bo'ladigan Promise qaytaradi (`{ value: data, done: false }`).
4. `for await...of` sikli qiymatni qabul qiladi. Sikl tanasi ushbu birinchi ma'lumot elementi bilan bajarilishni boshlaydi.
5. U `await slowConsumer(data)` ni chaqiradi. Buni bajarish uchun 500ms kerak bo'ladi.
6. Bu eng muhim qism: `for await...of` sikli `await slowConsumer(data)` promise'i hal bo'lmaguncha `producer.next()` ni qayta chaqirmaydi. Ishlab chiqaruvchi o'zining `yield` bayonotida to'xtab qoladi.
7. 500ms dan so'ng, `slowConsumer` tugaydi. Sikl tanasi ushbu iteratsiya uchun tugallanadi.
8. Endi va faqat endi, `for await...of` sikli keyingi elementni so'rash uchun `producer.next()` ni qayta chaqiradi.
9. `createFastProducer` funksiyasi to'xtagan joyidan davom etadi va o'zining `while` siklini davom ettiradi, 1-element uchun siklni qaytadan boshlaydi.

Iste'molchining qayta ishlash tezligi ishlab chiqaruvchining ishlab chiqarish tezligini bevosita nazorat qiladi. Bu tortishga asoslangan tizim (pull-based system) bo'lib, zamonaviy JavaScript'da nafis oqim boshqaruvining asosidir.

4. Ilg'or Andozalar va Haqiqiy Hayotdagi Qo'llash Holatlari

Asinxron generatorlarning haqiqiy kuchi siz ularni murakkab ma'lumotlarni o'zgartirish uchun konveyerlarga (pipelines) birlashtirishni boshlaganingizda namoyon bo'ladi.

Oqimlarni Yo'naltirish (Piping) va O'zgartirish (Transforming)

Xuddi Unix buyruqlar satrida buyruqlarni yo'naltirganingiz kabi (masalan, `cat log.txt | grep 'ERROR' | wc -l`), siz asinxron generatorlarni zanjir qilib bog'lashingiz mumkin. Transformator - bu shunchaki boshqa bir asinxron takrorlanuvchini (iterable) kirish sifatida qabul qiladigan va o'zgartirilgan ma'lumotlarni yield qiladigan asinxron generatordir.

Tasavvur qilaylik, biz savdo ma'lumotlariga ega katta CSV faylini qayta ishlayapmiz. Biz faylni o'qish, har bir qatorni tahlil qilish, yuqori qiymatli tranzaktsiyalarni filtrlash va keyin ularni ma'lumotlar bazasiga saqlashni xohlaymiz.

            
const fs = require('fs');
const { once } = require('events');

// ISH. CHIQARUVCHI: Katta faylni qatorma-qator o'qiydi
async function* readFileLines(filePath) {
  const readable = fs.createReadStream(filePath, { encoding: 'utf8' });
  let buffer = '';
  readable.on('data', chunk => {
    buffer += chunk;
    let newlineIndex;
    while ((newlineIndex = buffer.indexOf('\n')) >= 0) {
      const line = buffer.slice(0, newlineIndex);
      buffer = buffer.slice(newlineIndex + 1);
      readable.pause(); // Teskari bosim uchun Node.js oqimini aniq to'xtatish
      yield line;
    }
  });

  readable.on('end', () => {
    if (buffer.length > 0) {
      yield buffer; // Agar oxirgi yangi qator bo'lmasa, oxirgi qatorni yield qilish
    }
  });

  // Oqimning tugashi yoki xatolik yuz berishini kutishning soddalashtirilgan usuli
  await once(readable, 'close');
}

// TRANSFORMATOR 1: CSV qatorlarini ob'ektlarga tahlil qiladi
async function* parseCSV(lines) {
  for await (const line of lines) {
    const [id, product, amount] = line.split(',');
    if (id && product && amount) {
      yield { id, product, amount: parseFloat(amount) };
    }
  }
}

// TRANSFORMATOR 2: Yuqori qiymatli tranzaktsiyalarni filtrlaydi
async function* filterHighValue(transactions, minValue) {
  for await (const tx of transactions) {
    if (tx.amount >= minValue) {
      yield tx;
    }
  }
}

// ISTE'MOLCHI: Yakuniy ma'lumotlarni sekin ma'lumotlar bazasiga saqlaydi
async function saveToDatabase(transaction) {
  console.log(`Tranzaksiya ${transaction.id} ni ${transaction.amount} miqdori bilan MB ga saqlanmoqda...`);
  await new Promise(resolve => setTimeout(resolve, 100)); // Sekin MB yozishini simulyatsiya qilish
}

// --- Birlashtirilgan Konveyer ---
async function processSalesFile(filePath) {
  const lines = readFileLines(filePath);
  const transactions = parseCSV(lines);
  const highValueTxs = filterHighValue(transactions, 1000);

  console.log("ETL konveyeri ishga tushirilmoqda...");
  for await (const tx of highValueTxs) {
    await saveToDatabase(tx);
  }
  console.log("Konveyer tugadi.");
}

// Sinov uchun katta dummy CSV faylini yaratish
// fs.writeFileSync('sales.csv', ...);

// processSalesFile('sales.csv');


            

              
                Copy
              
            
          

Ushbu misolda teskari bosim zanjirning eng yuqorisigacha tarqaladi. `saveToDatabase` eng sekin qismdir. Uning `await` iborasi oxirgi `for await...of` siklini to'xtatib qo'yadi. Bu `filterHighValue` ni to'xtatadi, u esa `parseCSV` dan elementlarni so'rashni to'xtatadi, bu esa `readFileLines` dan elementlarni so'rashni to'xtatadi, bu esa oxir-oqibat Node.js fayl oqimiga diskdan o'qishni jismonan `pause()` qilishni aytadi. Butun tizim asinxron iteratsiyaning oddiy tortish mexanikasi tomonidan boshqarilib, minimal xotiradan foydalangan holda bir maromda harakat qiladi.

Xatoliklarni To'g'ri Boshqarish

Xatoliklarni boshqarish juda oddiy. Siz iste'molchi siklini `try...catch` blokiga o'rashingiz mumkin. Agar yuqoridagi generatorlardan birida xatolik yuzaga kelsa, u pastga tarqaladi va iste'molchi tomonidan ushlanadi.

            
async function* errorProneGenerator() {
  yield 1;
  yield 2;
  throw new Error("Generatorda nimadir noto'g'ri ketdi!");
  yield 3; // Bu hech qachon bajarilmaydi
}

async function main() {
  try {
    for await (const value of errorProneGenerator()) {
      console.log("Qabul qilindi:", value);
    }
  } catch (err) {
    console.error("Xato ushlandi:", err.message);
  }
}

main();
// Natija:
// Qabul qilindi: 1
// Qabul qilindi: 2
// Xato ushlandi: Generatorda nimadir noto'g'ri ketdi!

            

              
                Copy
              
            
          

`try...finally` Yordamida Resurslarni Tozalash

Agar iste'molchi qayta ishlashni erta to'xtatishga qaror qilsa (masalan, `break` iborasi yordamida)? Generator fayl dastaklari yoki ma'lumotlar bazasi ulanishlari kabi ochiq resurslarni ushlab qolishi mumkin. Generator ichidagi `finally` bloki tozalash uchun mukammal joydir.

`for await...of` sikli muddatidan oldin ( `break`, `return` yoki xatolik orqali) chiqib ketganda, u avtomatik ravishda generatorning `.return()` metodini chaqiradi. Bu esa generatorning o'zining `finally` blokiga o'tishiga sabab bo'ladi, bu esa sizga tozalash amallarini bajarish imkonini beradi.

            
async function* fileReaderWithCleanup(filePath) {
  let fileHandle;
  try {
    console.log("GENERATOR: Fayl ochilmoqda...");
    fileHandle = await fs.promises.open(filePath, 'r');
    // ... fayldan qatorlarni yield qilish mantig'i ...
    yield 'line 1';
    yield 'line 2';
    yield 'line 3';
  } finally {
    if (fileHandle) {
      console.log("GENERATOR: Fayl dastagi yopilmoqda.");
      await fileHandle.close();
    }
  }
}

async function main() {
  for await (const line of fileReaderWithCleanup('my-file.txt')) {
    console.log("ISTE'MOLCHI:", line);
    if (line === 'line 2') {
      console.log("ISTE'MOLCHI: Sikl erta to'xtatilmoqda.");
      break; // Sikldan chiqish
    }
  }
}

main();
// Natija:
// GENERATOR: Fayl ochilmoqda...
// ISTE'MOLCHI: line 1
// ISTE'MOLCHI: line 2
// ISTE'MOLCHI: Sikl erta to'xtatilmoqda.
// GENERATOR: Fayl dastagi yopilmoqda.

            

              
                Copy
              
            
          

5. Boshqa Teskari Bosim Mexanizmlari Bilan Taqqoslash

Asinxron generatorlar JavaScript ekotizimidagi teskari bosimni boshqarishning yagona usuli emas. Ularni boshqa mashhur yondashuvlar bilan qanday taqqoslanishini tushunish foydalidir.

Node.js Oqimlari (`.pipe()` va `pipeline`)

Node.js'da yillar davomida teskari bosimni boshqarib kelayotgan kuchli, o'rnatilgan Streams API mavjud. `readable.pipe(writable)` dan foydalanganingizda, Node.js ichki buferlar va `highWaterMark` sozlamasiga asoslanib ma'lumotlar oqimini boshqaradi. Bu o'rnatilgan teskari bosim mexanizmlariga ega bo'lgan voqealarga asoslangan, itarishga asoslangan tizimdir.

• Murakkablik: Node.js Streams API'sini to'g'ri amalga oshirish, ayniqsa maxsus transformatsiya oqimlari uchun, juda murakkab ekanligi ma'lum. Bu sinflarni kengaytirishni va ichki holat va voqealarni (`'data'`, `'end'`, `'drain'`) boshqarishni o'z ichiga oladi.
• Xatoliklarni Boshqarish: `.pipe()` bilan xatoliklarni boshqarish qiyin, chunki bitta oqimdagi xatolik avtomatik ravishda konveyerdagi boshqalarni yo'q qilmaydi. Shuning uchun `stream.pipeline` yanada ishonchli muqobil sifatida taqdim etilgan.
• O'qilishi: Asinxron generatorlar ko'pincha sinxronroq ko'rinadigan va o'qish va tushunish osonroq bo'lgan kodga olib keladi, ayniqsa murakkab transformatsiyalar uchun.

Node.js'da yuqori unumdorlikka ega, past darajadagi I/O uchun mahalliy Streams API hali ham ajoyib tanlovdir. Biroq, dastur darajasidagi mantiq va ma'lumotlarni o'zgartirish uchun asinxron generatorlar ko'pincha soddaroq va nafisroq ishlab chiquvchi tajribasini taqdim etadi.

Reaktiv Dasturlash (RxJS)

RxJS kabi kutubxonalar Observable (Kuzatiladigan) tushunchasidan foydalanadi. Node.js oqimlari singari, Observable'lar ham asosan itarishga asoslangan tizimdir. Ishlab chiqaruvchi (Observable) qiymatlarni chiqaradi va iste'molchi (Observer) ularga reaksiya bildiradi. RxJS'da teskari bosim avtomatik emas; uni `buffer`, `throttle`, `debounce` kabi turli operatorlar yoki maxsus rejalashtiruvchilar yordamida aniq boshqarish kerak.

• Paradigma: RxJS murakkab asinxron voqealar oqimlarini yaratish va boshqarish uchun kuchli funksional dasturlash paradigmasini taklif etadi. U UI voqealarini boshqarish kabi stsenariylar uchun juda kuchli.
• O'rganish Qiyinligi: RxJS o'zining ko'p sonli operatorlari va reaktiv dasturlash uchun talab qilinadigan fikrlash tarzining o'zgarishi tufayli o'rganish egri chizig'iga ega.
• Tortish va Itarish: Asosiy farq saqlanib qoladi. Asinxron generatorlar asosan tortishga asoslangan (iste'molchi nazorat qiladi), Observable'lar esa itarishga asoslangan (ishlab chiqaruvchi nazorat qiladi va iste'molchi bosimga reaksiya bildirishi kerak).

Asinxron generatorlar tilning mahalliy xususiyati bo'lib, ularni aks holda RxJS kabi keng qamrovli kutubxonani talab qilishi mumkin bo'lgan ko'plab teskari bosim muammolari uchun yengil va bog'liqliksiz tanlovga aylantiradi.

Xulosa: Tortish (Pull) Mexanizmini Qabul Qiling

Teskari bosim ixtiyoriy xususiyat emas; bu barqaror, kengaytiriladigan va xotira jihatidan samarali ma'lumotlarni qayta ishlash ilovalarini yaratish uchun fundamental talabdir. Uni e'tiborsiz qoldirish tizimning ishdan chiqishiga olib keladigan retseptdir.

Yillar davomida JavaScript dasturchilari oqimni boshqarish uchun murakkab, voqealarga asoslangan API'larga yoki uchinchi tomon kutubxonalariga tayanishgan. Asinxron generatorlar va `for await...of` sintaksisining joriy etilishi bilan endi bizda to'g'ridan-to'g'ri tilga o'rnatilgan kuchli, mahalliy va intuitiv vosita mavjud.

Itarishga asoslangan modeldan tortishga asoslangan modelga o'tish orqali asinxron generatorlar ichki teskari bosimni ta'minlaydi. Iste'molchining qayta ishlash tezligi tabiiy ravishda ishlab chiqaruvchining tezligini belgilaydi, bu esa quyidagi xususiyatlarga ega kodga olib keladi:

• Xotira Xavfsizligi: Cheksiz buferlarni yo'q qiladi va xotiradan tashqari (out-of-memory) ishdan chiqishlarning oldini oladi.
• O'qilishi Oson: Murakkab asinxron mantiqni oddiy, ketma-ket ko'rinadigan sikllarga aylantiradi.
• Birlashtirilishi Mumkin: Nafis, qayta ishlatiladigan ma'lumotlarni o'zgartirish konveyerlarini yaratish imkonini beradi.
• Mustahkam: Standart `try...catch...finally` bloklari bilan xatoliklarni boshqarish va resurslarni boshqarishni soddalashtiradi.

Keyingi safar ma'lumotlar oqimini qayta ishlashingiz kerak bo'lganda — u fayldan, API'dan yoki boshqa har qanday asinxron manbadan bo'lsin — qo'lda buferlash yoki murakkab qayta chaqiruvlarga murojaat qilmang. Asinxron generatorlarning tortishga asoslangan nafisligini qabul qiling. Bu sizning asinxron kodingizni toza, xavfsizroq va kuchliroq qiladigan zamonaviy JavaScript andozasidir.